home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / M2Crypto / X509.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  27.9 KB  |  755 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from M2Crypto import ASN1, BIO, Err, EVP, util
  5. import m2
  6. FORMAT_DER = 0
  7. FORMAT_PEM = 1
  8.  
  9. class X509Error(Exception):
  10.     pass
  11.  
  12. m2.x509_init(X509Error)
  13. V_OK = m2.X509_V_OK
  14.  
  15. def new_extension(name, value, critical = 0, _pyfree = 1):
  16.     if name == 'subjectKeyIdentifier' and value.strip('0123456789abcdefABCDEF:') is not '':
  17.         raise ValueError('value must be precomputed hash')
  18.     
  19.     lhash = m2.x509v3_lhash()
  20.     ctx = m2.x509v3_set_conf_lhash(lhash)
  21.     x509_ext_ptr = m2.x509v3_ext_conf(lhash, ctx, name, value)
  22.     x509_ext = X509_Extension(x509_ext_ptr, _pyfree)
  23.     x509_ext.set_critical(critical)
  24.     return x509_ext
  25.  
  26.  
  27. class X509_Extension:
  28.     m2_x509_extension_free = m2.x509_extension_free
  29.     
  30.     def __init__(self, x509_ext_ptr = None, _pyfree = 1):
  31.         self.x509_ext = x509_ext_ptr
  32.         self._pyfree = _pyfree
  33.  
  34.     
  35.     def __del__(self):
  36.         if getattr(self, '_pyfree', 0) and self.x509_ext:
  37.             self.m2_x509_extension_free(self.x509_ext)
  38.         
  39.  
  40.     
  41.     def _ptr(self):
  42.         return self.x509_ext
  43.  
  44.     
  45.     def set_critical(self, critical = 1):
  46.         return m2.x509_extension_set_critical(self.x509_ext, critical)
  47.  
  48.     
  49.     def get_critical(self):
  50.         return m2.x509_extension_get_critical(self.x509_ext)
  51.  
  52.     
  53.     def get_name(self):
  54.         return m2.x509_extension_get_name(self.x509_ext)
  55.  
  56.     
  57.     def get_value(self, flag = 0, indent = 0):
  58.         buf = BIO.MemoryBuffer()
  59.         m2.x509_ext_print(buf.bio_ptr(), self.x509_ext, flag, indent)
  60.         return buf.read_all()
  61.  
  62.  
  63.  
  64. class X509_Extension_Stack:
  65.     m2_sk_x509_extension_free = m2.sk_x509_extension_free
  66.     
  67.     def __init__(self, stack = None, _pyfree = 0):
  68.         if stack is not None:
  69.             self.stack = stack
  70.             self._pyfree = _pyfree
  71.             num = m2.sk_x509_extension_num(self.stack)
  72.             for i in range(num):
  73.                 self.pystack.append(X509_Extension(m2.sk_x509_extension_value(self.stack, i), _pyfree = _pyfree))
  74.             
  75.         else:
  76.             self.stack = m2.sk_x509_extension_new_null()
  77.             self._pyfree = 1
  78.             self.pystack = []
  79.  
  80.     
  81.     def __del__(self):
  82.         if getattr(self, '_pyfree', 0):
  83.             self.m2_sk_x509_extension_free(self.stack)
  84.         
  85.  
  86.     
  87.     def __len__(self):
  88.         return len(self.pystack)
  89.  
  90.     
  91.     def __getitem__(self, idx):
  92.         return self.pystack[idx]
  93.  
  94.     
  95.     def __iter__(self):
  96.         return iter(self.pystack)
  97.  
  98.     
  99.     def _ptr(self):
  100.         return self.stack
  101.  
  102.     
  103.     def push(self, x509_ext):
  104.         self.pystack.append(x509_ext)
  105.         ret = m2.sk_x509_extension_push(self.stack, x509_ext._ptr())
  106.         return ret
  107.  
  108.     
  109.     def pop(self):
  110.         x509_ext_ptr = m2.sk_x509_extension_pop(self.stack)
  111.         if x509_ext_ptr is None:
  112.             return None
  113.         
  114.         return self.pystack.pop()
  115.  
  116.  
  117.  
  118. class X509_Name_Entry:
  119.     m2_x509_name_entry_free = m2.x509_name_entry_free
  120.     
  121.     def __init__(self, x509_name_entry, _pyfree = 0):
  122.         self.x509_name_entry = x509_name_entry
  123.         self._pyfree = _pyfree
  124.  
  125.     
  126.     def __del__(self):
  127.         if getattr(self, '_pyfree', 0):
  128.             self.m2_x509_name_entry_free(self.x509_name_entry)
  129.         
  130.  
  131.     
  132.     def _ptr(self):
  133.         return self.x509_name_entry
  134.  
  135.     
  136.     def set_object(self, asn1obj):
  137.         return m2.x509_name_entry_set_object(self.x509_name_entry, asn1obj._ptr())
  138.  
  139.     
  140.     def set_data(self, data, type = ASN1.MBSTRING_ASC):
  141.         return m2.x509_name_entry_set_data(self.x509_name_entry, type, data)
  142.  
  143.     
  144.     def get_object(self):
  145.         return ASN1.ASN1_Object(m2.x509_name_entry_get_object(self.x509_name_entry))
  146.  
  147.     
  148.     def get_data(self):
  149.         return ASN1.ASN1_String(m2.x509_name_entry_get_data(self.x509_name_entry))
  150.  
  151.     
  152.     def create_by_txt(self, field, type, entry, len):
  153.         return m2.x509_name_entry_create_by_txt(self.x509_name_entry._ptr(), field, type, entry, len)
  154.  
  155.  
  156.  
  157. class X509_Name:
  158.     nid = {
  159.         'C': m2.NID_countryName,
  160.         'SP': m2.NID_stateOrProvinceName,
  161.         'ST': m2.NID_stateOrProvinceName,
  162.         'stateOrProvinceName': m2.NID_stateOrProvinceName,
  163.         'L': m2.NID_localityName,
  164.         'localityName': m2.NID_localityName,
  165.         'O': m2.NID_organizationName,
  166.         'organizationName': m2.NID_organizationName,
  167.         'OU': m2.NID_organizationalUnitName,
  168.         'organizationUnitName': m2.NID_organizationalUnitName,
  169.         'CN': m2.NID_commonName,
  170.         'commonName': m2.NID_commonName,
  171.         'Email': m2.NID_pkcs9_emailAddress,
  172.         'emailAddress': m2.NID_pkcs9_emailAddress,
  173.         'serialNumber': m2.NID_serialNumber,
  174.         'SN': m2.NID_surname,
  175.         'surname': m2.NID_surname,
  176.         'GN': m2.NID_givenName,
  177.         'givenName': m2.NID_givenName }
  178.     m2_x509_name_free = m2.x509_name_free
  179.     
  180.     def __init__(self, x509_name = None, _pyfree = 0):
  181.         if x509_name is not None:
  182.             self.x509_name = x509_name
  183.             self._pyfree = _pyfree
  184.         else:
  185.             self.x509_name = m2.x509_name_new()
  186.             self._pyfree = 1
  187.  
  188.     
  189.     def __del__(self):
  190.         if getattr(self, '_pyfree', 0):
  191.             self.m2_x509_name_free(self.x509_name)
  192.         
  193.  
  194.     
  195.     def __str__(self):
  196.         return m2.x509_name_oneline(self.x509_name)
  197.  
  198.     
  199.     def __getattr__(self, attr):
  200.         if attr in self.nid:
  201.             return m2.x509_name_by_nid(self.x509_name, self.nid[attr])
  202.         
  203.         if attr in self.__dict__:
  204.             return self.__dict__[attr]
  205.         
  206.         raise AttributeError, (self, attr)
  207.  
  208.     
  209.     def __setattr__(self, attr, value):
  210.         if attr in self.nid:
  211.             return m2.x509_name_set_by_nid(self.x509_name, self.nid[attr], value)
  212.         
  213.         self.__dict__[attr] = value
  214.  
  215.     
  216.     def __len__(self):
  217.         return m2.x509_name_entry_count(self.x509_name)
  218.  
  219.     
  220.     def __getitem__(self, idx):
  221.         if idx <= idx:
  222.             pass
  223.         elif not idx < self.entry_count():
  224.             raise IndexError('index out of range')
  225.         
  226.         return X509_Name_Entry(m2.x509_name_get_entry(self.x509_name, idx))
  227.  
  228.     
  229.     def __iter__(self):
  230.         for i in xrange(self.entry_count()):
  231.             yield self[i]
  232.         
  233.  
  234.     
  235.     def _ptr(self):
  236.         return self.x509_name
  237.  
  238.     
  239.     def add_entry_by_txt(self, field, type, entry, len, loc, set):
  240.         return m2.x509_name_add_entry_by_txt(self.x509_name, field, type, entry, len, loc, set)
  241.  
  242.     
  243.     def entry_count(self):
  244.         return m2.x509_name_entry_count(self.x509_name)
  245.  
  246.     
  247.     def get_entries_by_nid(self, nid):
  248.         ret = []
  249.         lastpos = -1
  250.         while True:
  251.             lastpos = m2.x509_name_get_index_by_nid(self.x509_name, nid, lastpos)
  252.             if lastpos == -1:
  253.                 break
  254.             
  255.             ret.append(self[lastpos])
  256.         return ret
  257.  
  258.     
  259.     def as_text(self, indent = 0, flags = m2.XN_FLAG_COMPAT):
  260.         buf = BIO.MemoryBuffer()
  261.         m2.x509_name_print_ex(buf.bio_ptr(), self.x509_name, indent, flags)
  262.         return buf.read_all()
  263.  
  264.     
  265.     def as_der(self):
  266.         return m2.x509_name_get_der(self.x509_name)
  267.  
  268.     
  269.     def as_hash(self):
  270.         return m2.x509_name_hash(self.x509_name)
  271.  
  272.  
  273.  
  274. class X509:
  275.     m2_x509_free = m2.x509_free
  276.     
  277.     def __init__(self, x509 = None, _pyfree = 0):
  278.         if x509 is not None:
  279.             self.x509 = x509
  280.             self._pyfree = _pyfree
  281.         else:
  282.             self.x509 = m2.x509_new()
  283.             self._pyfree = 1
  284.  
  285.     
  286.     def __del__(self):
  287.         if getattr(self, '_pyfree', 0):
  288.             self.m2_x509_free(self.x509)
  289.         
  290.  
  291.     
  292.     def _ptr(self):
  293.         return self.x509
  294.  
  295.     
  296.     def as_text(self):
  297.         buf = BIO.MemoryBuffer()
  298.         m2.x509_print(buf.bio_ptr(), self.x509)
  299.         return buf.read_all()
  300.  
  301.     
  302.     def as_der(self):
  303.         return m2.i2d_x509(self.x509)
  304.  
  305.     
  306.     def as_pem(self):
  307.         buf = BIO.MemoryBuffer()
  308.         m2.x509_write_pem(buf.bio_ptr(), self.x509)
  309.         return buf.read_all()
  310.  
  311.     
  312.     def save_pem(self, filename):
  313.         bio = BIO.openfile(filename, 'wb')
  314.         return m2.x509_write_pem(bio.bio_ptr(), self.x509)
  315.  
  316.     
  317.     def save(self, filename, format = FORMAT_PEM):
  318.         bio = BIO.openfile(filename, 'wb')
  319.         if format == FORMAT_PEM:
  320.             return m2.x509_write_pem(bio.bio_ptr(), self.x509)
  321.         elif format == FORMAT_DER:
  322.             return m2.i2d_x509_bio(bio.bio_ptr(), self.x509)
  323.         else:
  324.             raise ValueError('Unknown filetype. Must be either FORMAT_PEM or FORMAT_DER')
  325.  
  326.     
  327.     def set_version(self, version):
  328.         return m2.x509_set_version(self.x509, version)
  329.  
  330.     
  331.     def set_not_before(self, asn1_utctime):
  332.         return m2.x509_set_not_before(self.x509, asn1_utctime._ptr())
  333.  
  334.     
  335.     def set_not_after(self, asn1_utctime):
  336.         return m2.x509_set_not_after(self.x509, asn1_utctime._ptr())
  337.  
  338.     
  339.     def set_subject_name(self, name):
  340.         return m2.x509_set_subject_name(self.x509, name.x509_name)
  341.  
  342.     
  343.     def set_issuer_name(self, name):
  344.         return m2.x509_set_issuer_name(self.x509, name.x509_name)
  345.  
  346.     
  347.     def get_version(self):
  348.         return m2.x509_get_version(self.x509)
  349.  
  350.     
  351.     def get_serial_number(self):
  352.         asn1_integer = m2.x509_get_serial_number(self.x509)
  353.         return m2.asn1_integer_get(asn1_integer)
  354.  
  355.     
  356.     def set_serial_number(self, serial):
  357.         asn1_integer = m2.x509_get_serial_number(self.x509)
  358.         return m2.asn1_integer_set(asn1_integer, serial)
  359.  
  360.     
  361.     def get_not_before(self):
  362.         return ASN1.ASN1_UTCTIME(m2.x509_get_not_before(self.x509))
  363.  
  364.     
  365.     def get_not_after(self):
  366.         return ASN1.ASN1_UTCTIME(m2.x509_get_not_after(self.x509))
  367.  
  368.     
  369.     def get_pubkey(self):
  370.         return EVP.PKey(m2.x509_get_pubkey(self.x509), _pyfree = 1)
  371.  
  372.     
  373.     def set_pubkey(self, pkey):
  374.         return m2.x509_set_pubkey(self.x509, pkey.pkey)
  375.  
  376.     
  377.     def get_issuer(self):
  378.         return X509_Name(m2.x509_get_issuer_name(self.x509))
  379.  
  380.     
  381.     def set_issuer(self, name):
  382.         return m2.x509_set_issuer_name(self.x509, name.x509_name)
  383.  
  384.     
  385.     def get_subject(self):
  386.         return X509_Name(m2.x509_get_subject_name(self.x509))
  387.  
  388.     
  389.     def set_subject(self, name):
  390.         return m2.x509_set_subject_name(self.x509, name.x509_name)
  391.  
  392.     
  393.     def add_ext(self, ext):
  394.         return m2.x509_add_ext(self.x509, ext.x509_ext, -1)
  395.  
  396.     
  397.     def get_ext(self, name):
  398.         m2x509_get_ext = m2.x509_get_ext
  399.         m2x509_extension_get_name = m2.x509_extension_get_name
  400.         x509 = self.x509
  401.         for i in range(m2.x509_get_ext_count(x509)):
  402.             extPtr = m2x509_get_ext(x509, i)
  403.             if m2x509_extension_get_name(extPtr) == name:
  404.                 return X509_Extension(extPtr, _pyfree = 0)
  405.                 continue
  406.         
  407.         raise LookupError
  408.  
  409.     
  410.     def get_ext_at(self, index):
  411.         if index < 0 or index >= self.get_ext_count():
  412.             raise IndexError
  413.         
  414.         return X509_Extension(m2.x509_get_ext(self.x509, index), _pyfree = 0)
  415.  
  416.     
  417.     def get_ext_count(self):
  418.         return m2.x509_get_ext_count(self.x509)
  419.  
  420.     
  421.     def sign(self, pkey, md):
  422.         mda = getattr(m2, md, None)
  423.         if mda is None:
  424.             raise ValueError, ('unknown message digest', md)
  425.         
  426.         return m2.x509_sign(self.x509, pkey.pkey, mda())
  427.  
  428.     
  429.     def verify(self, pkey = None):
  430.         if pkey:
  431.             return m2.x509_verify(self.x509, pkey.pkey)
  432.         else:
  433.             return m2.x509_verify(self.x509, self.get_pubkey().pkey)
  434.  
  435.     
  436.     def check_ca(self):
  437.         return m2.x509_check_ca(self.x509)
  438.  
  439.     
  440.     def check_purpose(self, id, ca):
  441.         return m2.x509_check_purpose(self.x509, id, ca)
  442.  
  443.     
  444.     def get_fingerprint(self, md = 'md5'):
  445.         der = self.as_der()
  446.         md = EVP.MessageDigest(md)
  447.         md.update(der)
  448.         digest = md.final()
  449.         return hex(util.octx_to_num(digest))[2:-1].upper()
  450.  
  451.  
  452.  
  453. def load_cert(file, format = FORMAT_PEM):
  454.     bio = BIO.openfile(file)
  455.     if format == FORMAT_PEM:
  456.         return load_cert_bio(bio)
  457.     elif format == FORMAT_DER:
  458.         return X509(m2.d2i_x509(bio._ptr()), _pyfree = 1)
  459.     else:
  460.         raise ValueError('Unknown format. Must be either FORMAT_DER or FORMAT_PEM')
  461.  
  462.  
  463. def load_cert_bio(bio, format = FORMAT_PEM):
  464.     if format == FORMAT_PEM:
  465.         return X509(m2.x509_read_pem(bio._ptr()), 1)
  466.     elif format == FORMAT_DER:
  467.         return X509(m2.d2i_x509(bio._ptr()), _pyfree = 1)
  468.     else:
  469.         raise ValueError('Unknown format. Must be either FORMAT_DER or FORMAT_PEM')
  470.  
  471.  
  472. def load_cert_string(string, format = FORMAT_PEM):
  473.     bio = BIO.MemoryBuffer(string)
  474.     return load_cert_bio(bio, format)
  475.  
  476.  
  477. def load_cert_der_string(string):
  478.     bio = BIO.MemoryBuffer(string)
  479.     return X509(m2.d2i_x509(bio._ptr()), _pyfree = 1)
  480.  
  481.  
  482. class X509_Store_Context:
  483.     m2_x509_store_ctx_free = m2.x509_store_ctx_free
  484.     
  485.     def __init__(self, x509_store_ctx, _pyfree = 0):
  486.         self.ctx = x509_store_ctx
  487.         self._pyfree = _pyfree
  488.  
  489.     
  490.     def __del__(self):
  491.         if self._pyfree:
  492.             self.m2_x509_store_ctx_free(self.ctx)
  493.         
  494.  
  495.     
  496.     def _ptr(self):
  497.         return self.ctx
  498.  
  499.     
  500.     def get_current_cert(self):
  501.         return X509(m2.x509_store_ctx_get_current_cert(self.ctx), _pyfree = 0)
  502.  
  503.     
  504.     def get_error(self):
  505.         return m2.x509_store_ctx_get_error(self.ctx)
  506.  
  507.     
  508.     def get_error_depth(self):
  509.         return m2.x509_store_ctx_get_error_depth(self.ctx)
  510.  
  511.     
  512.     def get1_chain(self):
  513.         return X509_Stack(m2.x509_store_ctx_get1_chain(self.ctx), 1, 1)
  514.  
  515.  
  516.  
  517. class X509_Store:
  518.     m2_x509_store_free = m2.x509_store_free
  519.     
  520.     def __init__(self, store = None, _pyfree = 0):
  521.         if store is not None:
  522.             self.store = store
  523.             self._pyfree = _pyfree
  524.         else:
  525.             self.store = m2.x509_store_new()
  526.             self._pyfree = 1
  527.  
  528.     
  529.     def __del__(self):
  530.         if getattr(self, '_pyfree', 0):
  531.             self.m2_x509_store_free(self.store)
  532.         
  533.  
  534.     
  535.     def _ptr(self):
  536.         return self.store
  537.  
  538.     
  539.     def load_info(self, file):
  540.         m2.x509_store_load_locations(self.store, file)
  541.  
  542.     load_locations = load_info
  543.     
  544.     def add_x509(self, x509):
  545.         return m2.x509_store_add_cert(self.store, x509._ptr())
  546.  
  547.     add_cert = add_x509
  548.  
  549.  
  550. class X509_Stack:
  551.     m2_sk_x509_free = m2.sk_x509_free
  552.     
  553.     def __init__(self, stack = None, _pyfree = 0, _pyfree_x509 = 0):
  554.         if stack is not None:
  555.             self.stack = stack
  556.             self._pyfree = _pyfree
  557.             self.pystack = []
  558.             num = m2.sk_x509_num(self.stack)
  559.             for i in range(num):
  560.                 self.pystack.append(X509(m2.sk_x509_value(self.stack, i), _pyfree = _pyfree_x509))
  561.             
  562.         else:
  563.             self.stack = m2.sk_x509_new_null()
  564.             self._pyfree = 1
  565.             self.pystack = []
  566.  
  567.     
  568.     def __del__(self):
  569.         if getattr(self, '_pyfree', 0):
  570.             self.m2_sk_x509_free(self.stack)
  571.         
  572.  
  573.     
  574.     def __len__(self):
  575.         return len(self.pystack)
  576.  
  577.     
  578.     def __getitem__(self, idx):
  579.         return self.pystack[idx]
  580.  
  581.     
  582.     def __iter__(self):
  583.         return iter(self.pystack)
  584.  
  585.     
  586.     def _ptr(self):
  587.         return self.stack
  588.  
  589.     
  590.     def push(self, x509):
  591.         self.pystack.append(x509)
  592.         ret = m2.sk_x509_push(self.stack, x509._ptr())
  593.         return ret
  594.  
  595.     
  596.     def pop(self):
  597.         x509_ptr = m2.sk_x509_pop(self.stack)
  598.         if x509_ptr is None:
  599.             return None
  600.         
  601.         return self.pystack.pop()
  602.  
  603.     
  604.     def as_der(self):
  605.         return m2.get_der_encoding_stack(self.stack)
  606.  
  607.  
  608.  
  609. def new_stack_from_der(der_string):
  610.     stack_ptr = m2.make_stack_from_der_sequence(der_string)
  611.     return X509_Stack(stack_ptr, 1, 1)
  612.  
  613.  
  614. class Request:
  615.     m2_x509_req_free = m2.x509_req_free
  616.     
  617.     def __init__(self, req = None, _pyfree = 0):
  618.         if req is not None:
  619.             self.req = req
  620.             self._pyfree = _pyfree
  621.         else:
  622.             self.req = m2.x509_req_new()
  623.             self._pyfree = 1
  624.  
  625.     
  626.     def __del__(self):
  627.         if getattr(self, '_pyfree', 0):
  628.             self.m2_x509_req_free(self.req)
  629.         
  630.  
  631.     
  632.     def as_text(self):
  633.         buf = BIO.MemoryBuffer()
  634.         m2.x509_req_print(buf.bio_ptr(), self.req)
  635.         return buf.read_all()
  636.  
  637.     
  638.     def as_pem(self):
  639.         buf = BIO.MemoryBuffer()
  640.         m2.x509_req_write_pem(buf.bio_ptr(), self.req)
  641.         return buf.read_all()
  642.  
  643.     
  644.     def as_der(self):
  645.         buf = BIO.MemoryBuffer()
  646.         m2.i2d_x509_req_bio(buf.bio_ptr(), self.req)
  647.         return buf.read_all()
  648.  
  649.     
  650.     def save_pem(self, filename):
  651.         bio = BIO.openfile(filename, 'wb')
  652.         return m2.x509_req_write_pem(bio.bio_ptr(), self.req)
  653.  
  654.     
  655.     def save(self, filename, format = FORMAT_PEM):
  656.         bio = BIO.openfile(filename, 'wb')
  657.         if format == FORMAT_PEM:
  658.             return m2.x509_req_write_pem(bio.bio_ptr(), self.req)
  659.         elif format == FORMAT_DER:
  660.             return m2.i2d_x509_req_bio(bio.bio_ptr(), self.req)
  661.         else:
  662.             raise ValueError('Unknown filetype. Must be either FORMAT_DER or FORMAT_PEM')
  663.  
  664.     
  665.     def get_pubkey(self):
  666.         return EVP.PKey(m2.x509_req_get_pubkey(self.req), _pyfree = 1)
  667.  
  668.     
  669.     def set_pubkey(self, pkey):
  670.         return m2.x509_req_set_pubkey(self.req, pkey.pkey)
  671.  
  672.     
  673.     def get_version(self):
  674.         return m2.x509_req_get_version(self.req)
  675.  
  676.     
  677.     def set_version(self, version):
  678.         return m2.x509_req_set_version(self.req, version)
  679.  
  680.     
  681.     def get_subject(self):
  682.         return X509_Name(m2.x509_req_get_subject_name(self.req))
  683.  
  684.     
  685.     def set_subject_name(self, name):
  686.         return m2.x509_req_set_subject_name(self.req, name.x509_name)
  687.  
  688.     
  689.     def add_extensions(self, ext_stack):
  690.         return m2.x509_req_add_extensions(self.req, ext_stack._ptr())
  691.  
  692.     
  693.     def verify(self, pkey):
  694.         return m2.x509_req_verify(self.req, pkey.pkey)
  695.  
  696.     
  697.     def sign(self, pkey, md):
  698.         mda = getattr(m2, md, None)
  699.         if mda is None:
  700.             raise ValueError, ('unknown message digest', md)
  701.         
  702.         return m2.x509_req_sign(self.req, pkey.pkey, mda())
  703.  
  704.  
  705.  
  706. def load_request(file, format = FORMAT_PEM):
  707.     f = BIO.openfile(file)
  708.     if format == FORMAT_PEM:
  709.         cptr = m2.x509_req_read_pem(f.bio_ptr())
  710.     elif format == FORMAT_DER:
  711.         cptr = m2.d2i_x509_req(f.bio_ptr())
  712.     else:
  713.         raise ValueError('Unknown filetype. Must be either FORMAT_PEM or FORMAT_DER')
  714.     f.close()
  715.     if cptr is None:
  716.         raise Err.get_error()
  717.     
  718.     return Request(cptr, 1)
  719.  
  720.  
  721. class CRL:
  722.     m2_x509_crl_free = m2.x509_crl_free
  723.     
  724.     def __init__(self, crl = None, _pyfree = 0):
  725.         if crl is not None:
  726.             self.crl = crl
  727.             self._pyfree = _pyfree
  728.         else:
  729.             self.crl = m2.x509_crl_new()
  730.             self._pyfree = 1
  731.  
  732.     
  733.     def __del__(self):
  734.         if getattr(self, '_pyfree', 0):
  735.             self.m2_x509_crl_free(self.crl)
  736.         
  737.  
  738.     
  739.     def as_text(self):
  740.         buf = BIO.MemoryBuffer()
  741.         m2.x509_crl_print(buf.bio_ptr(), self.crl)
  742.         return buf.read_all()
  743.  
  744.  
  745.  
  746. def load_crl(file):
  747.     f = BIO.openfile(file)
  748.     cptr = m2.x509_crl_read_pem(f.bio_ptr())
  749.     f.close()
  750.     if cptr is None:
  751.         raise Err.get_error()
  752.     
  753.     return CRL(cptr, 1)
  754.  
  755.